home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / amusemen / nolan-1.1 / nolan.tar / nolan.c < prev    next >
C/C++ Source or Header  |  1994-04-25  |  12KB  |  501 lines
  1. /* 
  2.  * nolan.c --- interactive Nolan chart test for character displays
  3.  *
  4.  * by Eric S. Raymond <esr@snark.thyrsus.com>
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <unistd.h>
  9. #include <string.h>
  10. #include <signal.h>
  11. #include <ctype.h>
  12. #include <assert.h>
  13.  
  14. #include "screen.h"
  15.  
  16. #define CONTINUE    "Press any key to continue..."
  17. #define FINISH        "Press any key to finish..."
  18.  
  19. typedef int    bool;
  20. #define TRUE    1
  21. #define FALSE    0
  22.  
  23. /***************************************************************************
  24.  *
  25.  * Quiz interpreter state variables
  26.  *
  27.  ***************************************************************************/
  28.  
  29. #define MAXLABEL    16    /* maximum screens per program */
  30. #define MAXNAME        12    /* maximum characters per screen label */
  31. #define MAXQUES        10    /* maximum questions per screen */
  32. #define MAXLINE        132    /* allow for 80 characters plus markup */
  33.  
  34. typedef struct
  35. {
  36.     int    y, x;            /* location of question prompt */
  37.     char    label[MAXNAME];    /* the question label */
  38. }
  39. ques_t;
  40.  
  41. static ques_t    questions[MAXQUES];    /* current questions */    
  42. static int    nquestions;        /* number of labels */
  43. static long    found;            /* user took this before */
  44. static int    people;            /* count of people in scorefile */
  45. static int     lineno = 0;        /* script line number */
  46. static int     row;            /* current screen line */
  47. static int    score;            /* current scale score */
  48.  
  49. typedef int    (*intfunc)();        /* function returning integer */
  50.  
  51. /*
  52.  * Attribute stack handling.  We have to maintain a stack of currently
  53.  * active attributes so we'll be able to handle nested highlight marks
  54.  * properly.
  55.  */
  56. #define ATTRIB_STACK    10    /* way more than we should ever need */
  57. static int attribs[ATTRIB_STACK] = {'w'};
  58. static int *ap = attribs;
  59.  
  60. static void highlight();
  61.  
  62. /* special next-screen values */
  63. #define EXIT    -1
  64. #define NEXT    -2
  65.  
  66. /***************************************************************************
  67.  *
  68.  * Variables and data specific to the Nolan chart interpretation
  69.  *
  70.  ***************************************************************************/
  71. #define USERFILE    "nolan.sco"
  72.  
  73. /*
  74.  * These give the proper position of the user's asterisk in the 45-degree
  75.  * tilted grid of dots that is the Nolan chart.
  76.  */
  77. #define min(x, y)    (((x) > (y)) ? (y) : (x))
  78. #define OVER(p, e)      min(10 - p, e)            /* dots over */
  79. #define DOWN(p, e)    (20 - ((p) + (e)))        /* lines down */
  80.  
  81. static int    personal, economic;    /* self-government scores */
  82. static int    down;            /* countdown to user's chart line */
  83. static int    over;            /* count of dots to skip */
  84. static int    scatter[11][11];    /* scattergram data */
  85.  
  86. /* political types --- values uable directly as highlights */
  87. #define AUT    'm'    /* Authoritarians */
  88. #define CEN    'w'    /* Centrists */
  89. #define CON    'b'    /* Conservatives */
  90. #define LEF    'r'    /* Left Liberals */
  91. #define LIB    'g'    /* Libertarians */
  92.  
  93. /*
  94.  * This array translates from grid position to political type.
  95.  * As usual, vertical index is personal self-government,
  96.  * horizontal is economic self-government.
  97.  */
  98. static char scatcolors[11][11] =
  99. {
  100.     AUT, AUT, AUT, AUT, AUT, CON, CON, CON, CON, CON, CON,
  101.     AUT, AUT, AUT, AUT, AUT, CON, CON, CON, CON, CON, CON,
  102.     AUT, AUT, AUT, AUT, AUT, CON, CON, CON, CON, CON, CON,
  103.     AUT, AUT, AUT, AUT, AUT, CEN, CON, CON, CON, CON, CON,
  104.     AUT, AUT, AUT, AUT, CEN, CEN, CEN, CON, CON, CON, CON,
  105.     LEF, LEF, LEF, CEN, CEN, CEN, CEN, CEN, LIB, LIB, LIB,
  106.     LEF, LEF, LEF, LEF, CEN, CEN, CEN, LIB, LIB, LIB, LIB,
  107.     LEF, LEF, LEF, LEF, LEF, CEN, LIB, LIB, LIB, LIB, LIB,
  108.     LEF, LEF, LEF, LEF, LEF, LIB, LIB, LIB, LIB, LIB, LIB,
  109.     LEF, LEF, LEF, LEF, LEF, LIB, LIB, LIB, LIB, LIB, LIB,
  110.     LEF, LEF, LEF, LEF, LEF, LIB, LIB, LIB, LIB, LIB, LIB,
  111. };
  112.  
  113. /***************************************************************************
  114.  *
  115.  * Initialization and wrapup
  116.  *
  117.  ***************************************************************************/
  118.  
  119. /*ARGSUSED0*/
  120. static void wrapquiz(int dummy)
  121. /* end the quiz, either normally or due to signal */
  122. {
  123.     endscreen();
  124.     exit(0);
  125. } 
  126.  
  127. static void initquiz(void)
  128. /* make sure we clean up properly on exit */
  129. {
  130.     (void) signal(SIGINT,wrapquiz);
  131.     (void) signal(SIGINT,wrapquiz);
  132.     (void) signal(SIGIOT,wrapquiz);        /* for assert(3) */
  133.     if (signal(SIGQUIT,SIG_IGN) != SIG_IGN)
  134.     (void) signal(SIGQUIT,wrapquiz);
  135.  
  136.     initscreen();
  137. }            
  138.  
  139. /***************************************************************************
  140.  *
  141.  * Utility functions
  142.  *
  143.  ***************************************************************************/
  144.  
  145. #define CENTER(str)    ((COLS - reallength(str)) / 2)
  146. #define RIGHT(str)    (COLS - reallength(str) - 1)
  147.  
  148. static int reallength(char *str)
  149. /* compute the "real" length of a string, not counting @{}-constructs */
  150. {
  151.     char    *cp;
  152.     int        i = 0;
  153.  
  154.     for (cp = str; *cp; cp++)
  155.     if (cp[0] == '@' && (cp[1] == '@' || cp[1] == '}'))
  156.     {
  157.         i++;
  158.         cp++;
  159.     }
  160.     else if (cp[0] == '}')
  161.         continue;
  162.     else if (cp[0] == '@')
  163.         i -= 2;
  164.     else
  165.         i++;
  166.  
  167.     return(i);
  168. }
  169.  
  170. /***************************************************************************
  171.  *
  172.  * The quiz interpreter
  173.  *
  174.  ***************************************************************************/
  175.  
  176. static void display(char *oline)
  177. /* display text, doing highlighting and parsing question blocks */
  178. {
  179.     char    *cp, *ep, line[MAXLINE];
  180.  
  181.     /*
  182.      * KLUGE ALERT:
  183.      *
  184.      * Avoid putting out a line feed on the last line, it may cause a scroll.
  185.      * Unfortunately, we have to copy the line to avoid modifying an immutable
  186.      * string.
  187.      */
  188.     (void) strcpy(line, oline);
  189.     if (row == LINES - 1 && (cp = strchr(line, '\n')))
  190.     *cp = '\0';
  191.  
  192.     over = 0;
  193.     for (cp = line; *cp; cp++)
  194.     {
  195.     if (cp[0] == '@' && (cp[1] == '@' || cp[1] == '}' || cp[1] == '%'))
  196.     {
  197.         ++cp;
  198.         sputc(*cp);
  199.     }
  200.     else if (cp[0] == '}' && ap > attribs)
  201.     {
  202.         if (ap > attribs)
  203.         --ap;
  204.         sattrset(*ap);
  205.     }
  206.     else if (cp[0] == '%')
  207.     {
  208.         /* these allow us to display the user's scores numerically */
  209.         if (cp[1] == 'E')
  210.         {
  211.         scprintf("%-3d", economic * 10);
  212.         cp +=2;
  213.         }
  214.         else if (cp[1] == 'P')
  215.         {
  216.         scprintf("%-3d", personal * 10);
  217.         cp += 2;
  218.         }
  219.         else if (cp[1] == 'N')
  220.         {
  221.         scprintf("%-3d", people);
  222.         cp += 2;
  223.         }
  224.         else
  225.         sputc(*cp);
  226.     }
  227.     else if (down == 0 && cp[0] == '.')
  228.     {
  229.         if (over == OVER(personal, economic))
  230.         {
  231.         highlight();
  232.         sputc('*');
  233.         sattrset(*ap);
  234.         }
  235.         else
  236.         sputc(*cp);
  237.         over++;
  238.     }
  239.     else if (cp[0] != '@')
  240.     {
  241.         sputc(*cp);
  242.     }
  243.     else
  244.     {
  245.         ep = strchr(cp, '}');
  246.         if (cp[2] != '{')
  247.         {
  248.         endscreen();
  249.         (void) fprintf(stderr,
  250.                    "quiz: bad markup syntax, line %d\n",
  251.                    lineno);
  252.         exit(1);
  253.         }
  254.  
  255.         if (ep == (char *)NULL)
  256.         {
  257.         endscreen();
  258.         (void) fprintf(stderr,
  259.                    "quiz: no markup terminator, line %d\n",
  260.                    lineno);
  261.         exit(1);
  262.         }
  263.  
  264.         /* character span from cp+3 to ep-1 is {}-enclosed part */
  265.         if (attrok(cp[1]))
  266.         {
  267.         sattrset(cp[1]);
  268.         *++ap = cp[1];
  269.         cp += 2;
  270.         continue;
  271.         }
  272.         else if (cp[1] == 'q')
  273.         {
  274.         /* accumulate this question label and its location */
  275.         screenloc(
  276.               &questions[nquestions].y,
  277.               &questions[nquestions].x);
  278.         *ep = '\0';
  279.         (void) strcpy(questions[nquestions].label, cp + 3);
  280.         *ep = '}';
  281.         nquestions++;
  282.  
  283.         /* skip this command in further parsing */
  284.         if (ep)
  285.             cp = ep;
  286.         }
  287.         else
  288.         {
  289.         endscreen();
  290.         (void) fprintf(stderr,
  291.                    "quiz: bad markup letter %c, line %d\n",
  292.                    cp[1], lineno);
  293.         exit(1);
  294.         }
  295.     }
  296.     }
  297.     row++;
  298.     down--;
  299. }
  300.  
  301. static void doquestions(void)
  302. /* interpret and ask the questions found by a screen parse */
  303. {
  304.     int    i, response;
  305.  
  306.     for (i = 0; i < nquestions; i++)
  307.     {
  308.     do {
  309.         movecursor(questions[i].y, questions[i].x);
  310.         response = tolower(sgetch());
  311.         highlight();
  312.         sputc(response);
  313.         sattrset(*ap);
  314.     } while
  315.         (response != 'y' && response != 'm' && response != 'n');
  316.  
  317.     if (response == 'y')
  318.         score += 2;
  319.     else if (response == 'm')
  320.         score += 1;
  321.     else if (response == 'n')
  322.         score += 0;
  323.     }
  324. }
  325.  
  326. static void scattergram(void)
  327. /* plot a scattergram from the response totals */
  328. {
  329.     int    p, e;
  330.  
  331.     for (p = 10; p >= 0; p--)
  332.     {
  333.     sattrset('b');
  334.     scprintf("%-3d", p * 10);
  335.     sattrset('w');
  336.     sputs(" |");
  337.     for (e = 0; e <= 10; e++)
  338.     {
  339.         sattrset(scatcolors[e][p]);
  340.         if (scatter[e][p])
  341.         scprintf(" %4d ", scatter[e][p]);
  342.         else
  343.         sputs("    . ");
  344.         sattrset('w');
  345.     }
  346.     sputs("\n");
  347.     }
  348.  
  349.     sputs("    +-----------------------------------------------------------------\n");
  350.     sattrset('r');
  351.     sputs("         0    10    20    30    40    50    60    70    80    90   100\n");
  352.     sattrset('w');
  353. }
  354.  
  355. static int screenend(int next, int *scoretype)
  356. /* handle end-of-screen */
  357. {
  358.     char    *exitprompt = (next == EXIT) ? FINISH : CONTINUE;
  359.  
  360.     doquestions();
  361.     if (scoretype)
  362.     *scoretype = score;
  363.  
  364.     /*
  365.      * The -1 offset below copes with curses implementations that
  366.      * don't do the right thing to suppress autoscroll when putting
  367.      * a character into the last screen position.
  368.      */
  369.     movecursor(LINES - 1, RIGHT(exitprompt) - 1);
  370.     highlight();
  371.     sputs(exitprompt);
  372.     sattrset(*ap);
  373.     (void) sgetch();
  374.  
  375.     return(next);
  376. }
  377.  
  378. /* ARGSUSED0 */
  379. static void screen(char *name)
  380. /* get ready for a new screen */
  381. {
  382. }
  383.  
  384. /***************************************************************************
  385.  *
  386.  * Quiz gets included here
  387.  *    The problem: we want the convenience of a data-driven program (being
  388.  * able to easily change the script contents and its markup with a text
  389.  * editor).  But...we *don't* want the script exposed to errors or malice.
  390.  * So --- we compile the script into executable code.  No muss, no fuss,
  391.  * and the retrieval is faster.
  392.  *    The only drawback is that it's now painful to modify the script and
  393.  * regenerate this program unless you have a UNIX to work with..
  394.  *
  395.  ***************************************************************************/
  396.  
  397. static int dispatch(void);
  398.  
  399. #include "script.h"
  400.  
  401. #ifndef STANDOUT
  402. #define STANDOUT    'y'
  403. #endif
  404.  
  405. static void highlight()
  406. /* start highlight --- define this here to pick up generated STANDOUT value */
  407. {
  408.     sattrset(STANDOUT[0]);
  409. }
  410.  
  411. static int dispatch(void)
  412. /* dispatch on user's political type */
  413. {
  414.     switch (scatcolors[personal][economic])
  415.     {
  416.     case AUT:
  417.     return(AUT_SCREEN);
  418.  
  419.     case CON:
  420.     return(CON_SCREEN);
  421.  
  422.     case CEN:
  423.     return(CEN_SCREEN);
  424.  
  425.     case LEF:
  426.     return(LEF_SCREEN);
  427.  
  428.     case LIB:
  429.     return(LIB_SCREEN);
  430.     }
  431.     return(NEXT);
  432. }
  433.  
  434. /***************************************************************************
  435.  *
  436.  * Main sequence
  437.  *
  438.  ***************************************************************************/
  439.  
  440. /*ARGSUSED0*/
  441. main(int argc, char *argv[])
  442. {
  443.     char    buf[BUFSIZ], *user = username();
  444.     FILE    *ufp = (FILE *)NULL;
  445.     long    offset;
  446.     int        screen;
  447.  
  448.     static bool quizline(char *line);
  449.  
  450.     /* see whether user has done this before */
  451.     found = -1;
  452.     offset = 0L;
  453.     if ((ufp = fopen(USERFILE, "r+")) != (FILE *)NULL)
  454.     {
  455.     int    pers, eco;
  456.  
  457.     while (fscanf(ufp, "%[^:]:%d:%d\n", buf, &pers, &eco) == 3)
  458.     {
  459.         if (strcmp(buf, user) == 0)
  460.         found = offset;
  461.         else
  462.         scatter[pers / 10][eco / 10]++;
  463.         offset = ftell(ufp);
  464.         people++;
  465.     }
  466.     }
  467.  
  468.     /* set up the screen */
  469.     initquiz();
  470.  
  471.     /* interpret the quiz */
  472.     screen = 0;
  473.     for (;;)
  474.     {
  475.     int    next = (*screenfuncs[screen])();
  476.  
  477.     if (next == EXIT)
  478.         break;
  479.     else if (next == NEXT)
  480.         screen++;
  481.     else
  482.         screen = next;
  483.     }
  484.  
  485.     /* we're done */
  486.     endscreen();
  487.  
  488.     /* record user's scores in case he/she takes the quiz again */
  489.     if (ufp)
  490.     {
  491.     if (found > -1)
  492.         (void) fseek(ufp, found, SEEK_SET);
  493.     (void) fprintf(ufp, "%s:%03d:%03d\n", user, personal*10, economic*10);
  494.     (void) fclose(ufp);
  495.     }
  496.  
  497.     return(0);
  498. }
  499.  
  500. /* nolan.c ends here */
  501.